import config from '../config/index.js'

/**
 * 获取当前页面路径
 * @returns {string} 当前页面路径
 */
const getCurrentPagePath = () => {
  const pages = getCurrentPages()
  const currentPage = pages[pages.length - 1]
  return currentPage ? `/${currentPage.route}` : ''
}

/**
 * 获取当前页面完整路径（包含参数）
 * @returns {string} 当前页面完整路径
 */
const getCurrentPageFullPath = () => {
  const pages = getCurrentPages()
  const currentPage = pages[pages.length - 1]
  if (!currentPage) return ''
  
  const { route, options } = currentPage
  let fullPath = `/${route}`
  
  if (options && Object.keys(options).length > 0) {
    const params = Object.keys(options)
      .map(key => `${key}=${options[key]}`)
      .join('&')
    fullPath += `?${params}`
  }
  
  return fullPath
}

/**
 * 检查当前页面是否在白名单中
 * @param {string} path 页面路径
 * @returns {boolean} 是否在白名单中
 */
const isInWhiteList = (path) => {
  const { whiteList } = config.routeGuard
  return whiteList.some(item => {
    // 支持路径匹配和正则匹配
    if (typeof item === 'string') {
      return path === item || path.startsWith(item + '?')
    } else if (item instanceof RegExp) {
      return item.test(path)
    }
    return false
  })
}

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
const isLoggedIn = () => {
  const token = uni.getStorageSync(config.routeGuard.tokenKey)
  return !!token
}

/**
 * 跳转到登录页
 * @param {string} redirectPath 登录后需要跳转的页面路径
 */
const navigateToLogin = (redirectPath) => {
  const { loginPath, redirectKey } = config.routeGuard
  
  // 构建登录页URL，包含重定向参数
  let loginUrl = loginPath
  if (redirectPath) {
    // 对重定向路径进行编码，避免特殊字符问题
    const encodedRedirect = encodeURIComponent(redirectPath)
    loginUrl += `?${redirectKey}=${encodedRedirect}`
  }
  // 跳转到登录页
  uni.navigateTo({
    url: loginUrl
  })
}

/**
 * 跳转到指定页面
 * @param {string} path 页面路径
 * @param {Object} options 跳转选项
 */
const navigateTo = (path, options = {}) => {
  const { isTabBar = false } = options
  if (isTabBar) {
    uni.switchTab({ url: path })
  } else {
    uni.navigateTo({ url: path })
  }
}

/**
 * 路由守卫
 * 在页面跳转前进行登录校验
 * @param {string} to 目标页面路径
 * @param {Object} options 跳转选项
 * @returns {boolean} 是否允许跳转
 */
const routeGuard = (to, options = {}) => {
  // 如果未启用路由守卫，直接允许跳转
  if (!config.routeGuard.enable) {
    return true
  }
  
  if (!to) {
    return true
  }

  // 检查目标页面是否在白名单中
  console.log('目标页面路径:', to)
  if (isInWhiteList(to)) {
    return true
  }

  console.log('检查用户是否已登录:', isLoggedIn())
  // 检查用户是否已登录
  if (isLoggedIn()) {
    return true
  }
  
  console.log('未登录，跳转到登录页')
  // 未登录，跳转到登录页
  navigateToLogin(to)
  return false
}

/**
 * 登录成功后的处理
 * 跳转到之前访问的页面或默认页面
 * @param {string} defaultPath 默认跳转路径
 */
const loginSuccess = (defaultPath = '/pages/index/index') => {
  // 获取重定向路径
  const pages = getCurrentPages()
  const currentPage = pages[pages.length - 1]
  console.log('当前页面:', currentPage)
  console.log('currentPage.route:', currentPage.route)
  if (currentPage && currentPage.route === 'pages/login/login') {
    // 从登录页获取重定向参数
    const { redirect } = currentPage.options || {}
    console.log('redirect:', redirect)
    if (redirect) {
      // 解码重定向路径
      const decodedRedirect = decodeURIComponent(redirect)
      
      // 登录成功后，直接跳转到重定向页面
      // 判断是否为TabBar页面
      const isTabBar = config.routeGuard.tabBarPages.includes(decodedRedirect)
      redirectTo(decodedRedirect, { isTabBar })
      return
    }
  }
  
  // 没有重定向路径或重定向路径无效，跳转到默认页面
  redirectTo(defaultPath, { isTabBar: true })
}

const redirectTo = (path, options = {}) => {
  const { isTabBar = false } = options
  if (isTabBar) {
    uni.switchTab({ url: path })
  } else {
    uni.redirectTo({ url: path })
  }
}

/**
 * 退出登录处理
 * 清除登录状态并跳转到首页
 */
const logout = () => {
  // 清除token
  uni.removeStorageSync(config.routeGuard.tokenKey)
  
  // 跳转到首页
  navigateTo('/pages/index/index', { isTabBar: true })
}

/**
 * 全局拦截 uni-app 的页面跳转方法
 * 在跳转前进行路由守卫检查
 */
const setupRouteInterceptor = () => {
  // 保存原始方法
  const originalNavigateTo = uni.navigateTo
  const originalRedirectTo = uni.redirectTo
  const originalReLaunch = uni.reLaunch
  const originalSwitchTab = uni.switchTab
  
  // 拦截 navigateTo
  uni.navigateTo = (options) => {
    const { url } = options
    if (!routeGuard(url)) {
      return // 如果路由守卫返回false，则不执行跳转
    }
    return originalNavigateTo.call(uni, options)
  }
  
  // 拦截 redirectTo
  uni.redirectTo = (options) => {
    const { url } = options
    if (!routeGuard(url)) {
      return // 如果路由守卫返回false，则不执行跳转
    }
    return originalRedirectTo.call(uni, options)
  }
  
  // 拦截 reLaunch
  uni.reLaunch = (options) => {
    const { url } = options
    if (!routeGuard(url)) {
      return // 如果路由守卫返回false，则不执行跳转
    }
    return originalReLaunch.call(uni, options)
  }
  
  // 拦截 switchTab
  uni.switchTab = (options) => {
    const { url } = options
    if (!routeGuard(url)) {
      return // 如果路由守卫返回false，则不执行跳转
    }
    return originalSwitchTab.call(uni, options)
  }
}

export default {
  getCurrentPagePath,
  getCurrentPageFullPath,
  isInWhiteList,
  isLoggedIn,
  navigateToLogin,
  navigateTo,
  routeGuard,
  loginSuccess,
  logout,
  setupRouteInterceptor,
}